
/*

  KLayout Layout Viewer
  Copyright (C) 2006-2025 Matthias Koefferlein

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

/**
*  @file gsiDeclQRgba64.cc 
*
*  DO NOT EDIT THIS FILE. 
*  This file has been created automatically
*/

#include <QRgba64>
#include "gsiQt.h"
#include "gsiQtGuiCommon.h"
#include <memory>

// -----------------------------------------------------------------------
// class QRgba64

//  Constructor QRgba64::QRgba64()


static void _init_ctor_QRgba64_0 (qt_gsi::GenericStaticMethod *decl)
{
  decl->set_return_new<QRgba64> ();
}

static void _call_ctor_QRgba64_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<QRgba64 *> (new QRgba64 ());
}


// quint16 QRgba64::alpha()


static void _init_f_alpha_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<quint16 > ();
}

static void _call_f_alpha_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<quint16 > ((quint16)((QRgba64 *)cls)->alpha ());
}


// quint8 QRgba64::alpha8()


static void _init_f_alpha8_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<quint8 > ();
}

static void _call_f_alpha8_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<quint8 > ((quint8)((QRgba64 *)cls)->alpha8 ());
}


// quint16 QRgba64::blue()


static void _init_f_blue_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<quint16 > ();
}

static void _call_f_blue_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<quint16 > ((quint16)((QRgba64 *)cls)->blue ());
}


// quint8 QRgba64::blue8()


static void _init_f_blue8_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<quint8 > ();
}

static void _call_f_blue8_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<quint8 > ((quint8)((QRgba64 *)cls)->blue8 ());
}


// quint16 QRgba64::green()


static void _init_f_green_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<quint16 > ();
}

static void _call_f_green_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<quint16 > ((quint16)((QRgba64 *)cls)->green ());
}


// quint8 QRgba64::green8()


static void _init_f_green8_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<quint8 > ();
}

static void _call_f_green8_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<quint8 > ((quint8)((QRgba64 *)cls)->green8 ());
}


// bool QRgba64::isOpaque()


static void _init_f_isOpaque_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

static void _call_f_isOpaque_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<bool > ((bool)((QRgba64 *)cls)->isOpaque ());
}


// bool QRgba64::isTransparent()


static void _init_f_isTransparent_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

static void _call_f_isTransparent_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<bool > ((bool)((QRgba64 *)cls)->isTransparent ());
}


// QRgba64 &QRgba64::operator=(quint64 _rgba)


static void _init_f_operator_eq__1103 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("_rgba");
  decl->add_arg<quint64 > (argspec_0);
  decl->set_return<QRgba64 & > ();
}

static void _call_f_operator_eq__1103 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  quint64 arg1 = gsi::arg_reader<quint64 >() (args, heap);
  ret.write<QRgba64 & > ((QRgba64 &)((QRgba64 *)cls)->operator= (arg1));
}


// QRgba64 QRgba64::premultiplied()


static void _init_f_premultiplied_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QRgba64 > ();
}

static void _call_f_premultiplied_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<QRgba64 > ((QRgba64)((QRgba64 *)cls)->premultiplied ());
}


// quint16 QRgba64::red()


static void _init_f_red_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<quint16 > ();
}

static void _call_f_red_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<quint16 > ((quint16)((QRgba64 *)cls)->red ());
}


// quint8 QRgba64::red8()


static void _init_f_red8_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<quint8 > ();
}

static void _call_f_red8_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<quint8 > ((quint8)((QRgba64 *)cls)->red8 ());
}


// void QRgba64::setAlpha(quint16 _alpha)


static void _init_f_setAlpha_1100 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("_alpha");
  decl->add_arg<quint16 > (argspec_0);
  decl->set_return<void > ();
}

static void _call_f_setAlpha_1100 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  quint16 arg1 = gsi::arg_reader<quint16 >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QRgba64 *)cls)->setAlpha (arg1);
}


// void QRgba64::setBlue(quint16 _blue)


static void _init_f_setBlue_1100 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("_blue");
  decl->add_arg<quint16 > (argspec_0);
  decl->set_return<void > ();
}

static void _call_f_setBlue_1100 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  quint16 arg1 = gsi::arg_reader<quint16 >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QRgba64 *)cls)->setBlue (arg1);
}


// void QRgba64::setGreen(quint16 _green)


static void _init_f_setGreen_1100 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("_green");
  decl->add_arg<quint16 > (argspec_0);
  decl->set_return<void > ();
}

static void _call_f_setGreen_1100 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  quint16 arg1 = gsi::arg_reader<quint16 >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QRgba64 *)cls)->setGreen (arg1);
}


// void QRgba64::setRed(quint16 _red)


static void _init_f_setRed_1100 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("_red");
  decl->add_arg<quint16 > (argspec_0);
  decl->set_return<void > ();
}

static void _call_f_setRed_1100 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  quint16 arg1 = gsi::arg_reader<quint16 >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QRgba64 *)cls)->setRed (arg1);
}


// unsigned int QRgba64::toArgb32()


static void _init_f_toArgb32_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<unsigned int > ();
}

static void _call_f_toArgb32_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<unsigned int > ((unsigned int)((QRgba64 *)cls)->toArgb32 ());
}


// unsigned short int QRgba64::toRgb16()


static void _init_f_toRgb16_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<unsigned short int > ();
}

static void _call_f_toRgb16_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<unsigned short int > ((unsigned short int)((QRgba64 *)cls)->toRgb16 ());
}


// QRgba64 QRgba64::unpremultiplied()


static void _init_f_unpremultiplied_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QRgba64 > ();
}

static void _call_f_unpremultiplied_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<QRgba64 > ((QRgba64)((QRgba64 *)cls)->unpremultiplied ());
}


// static QRgba64 QRgba64::fromArgb32(unsigned int rgb)


static void _init_f_fromArgb32_1772 (qt_gsi::GenericStaticMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("rgb");
  decl->add_arg<unsigned int > (argspec_0);
  decl->set_return<QRgba64 > ();
}

static void _call_f_fromArgb32_1772 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  unsigned int arg1 = gsi::arg_reader<unsigned int >() (args, heap);
  ret.write<QRgba64 > ((QRgba64)QRgba64::fromArgb32 (arg1));
}


// static QRgba64 QRgba64::fromRgba(quint8 red, quint8 green, quint8 blue, quint8 alpha)


static void _init_f_fromRgba_3888 (qt_gsi::GenericStaticMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("red");
  decl->add_arg<quint8 > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("green");
  decl->add_arg<quint8 > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("blue");
  decl->add_arg<quint8 > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("alpha");
  decl->add_arg<quint8 > (argspec_3);
  decl->set_return<QRgba64 > ();
}

static void _call_f_fromRgba_3888 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  quint8 arg1 = gsi::arg_reader<quint8 >() (args, heap);
  quint8 arg2 = gsi::arg_reader<quint8 >() (args, heap);
  quint8 arg3 = gsi::arg_reader<quint8 >() (args, heap);
  quint8 arg4 = gsi::arg_reader<quint8 >() (args, heap);
  ret.write<QRgba64 > ((QRgba64)QRgba64::fromRgba (arg1, arg2, arg3, arg4));
}


// static QRgba64 QRgba64::fromRgba64(quint64 c)


static void _init_f_fromRgba64_1103 (qt_gsi::GenericStaticMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("c");
  decl->add_arg<quint64 > (argspec_0);
  decl->set_return<QRgba64 > ();
}

static void _call_f_fromRgba64_1103 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  quint64 arg1 = gsi::arg_reader<quint64 >() (args, heap);
  ret.write<QRgba64 > ((QRgba64)QRgba64::fromRgba64 (arg1));
}


// static QRgba64 QRgba64::fromRgba64(quint16 red, quint16 green, quint16 blue, quint16 alpha)


static void _init_f_fromRgba64_4076 (qt_gsi::GenericStaticMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("red");
  decl->add_arg<quint16 > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("green");
  decl->add_arg<quint16 > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("blue");
  decl->add_arg<quint16 > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("alpha");
  decl->add_arg<quint16 > (argspec_3);
  decl->set_return<QRgba64 > ();
}

static void _call_f_fromRgba64_4076 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  quint16 arg1 = gsi::arg_reader<quint16 >() (args, heap);
  quint16 arg2 = gsi::arg_reader<quint16 >() (args, heap);
  quint16 arg3 = gsi::arg_reader<quint16 >() (args, heap);
  quint16 arg4 = gsi::arg_reader<quint16 >() (args, heap);
  ret.write<QRgba64 > ((QRgba64)QRgba64::fromRgba64 (arg1, arg2, arg3, arg4));
}



namespace gsi
{

static gsi::Methods methods_QRgba64 () {
  gsi::Methods methods;
  methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QRgba64::QRgba64()\nThis method creates an object of class QRgba64.", &_init_ctor_QRgba64_0, &_call_ctor_QRgba64_0);
  methods += new qt_gsi::GenericMethod (":alpha", "@brief Method quint16 QRgba64::alpha()\n", true, &_init_f_alpha_c0, &_call_f_alpha_c0);
  methods += new qt_gsi::GenericMethod ("alpha8", "@brief Method quint8 QRgba64::alpha8()\n", true, &_init_f_alpha8_c0, &_call_f_alpha8_c0);
  methods += new qt_gsi::GenericMethod (":blue", "@brief Method quint16 QRgba64::blue()\n", true, &_init_f_blue_c0, &_call_f_blue_c0);
  methods += new qt_gsi::GenericMethod ("blue8", "@brief Method quint8 QRgba64::blue8()\n", true, &_init_f_blue8_c0, &_call_f_blue8_c0);
  methods += new qt_gsi::GenericMethod (":green", "@brief Method quint16 QRgba64::green()\n", true, &_init_f_green_c0, &_call_f_green_c0);
  methods += new qt_gsi::GenericMethod ("green8", "@brief Method quint8 QRgba64::green8()\n", true, &_init_f_green8_c0, &_call_f_green8_c0);
  methods += new qt_gsi::GenericMethod ("isOpaque?", "@brief Method bool QRgba64::isOpaque()\n", true, &_init_f_isOpaque_c0, &_call_f_isOpaque_c0);
  methods += new qt_gsi::GenericMethod ("isTransparent?", "@brief Method bool QRgba64::isTransparent()\n", true, &_init_f_isTransparent_c0, &_call_f_isTransparent_c0);
  methods += new qt_gsi::GenericMethod ("assign", "@brief Method QRgba64 &QRgba64::operator=(quint64 _rgba)\n", false, &_init_f_operator_eq__1103, &_call_f_operator_eq__1103);
  methods += new qt_gsi::GenericMethod ("premultiplied", "@brief Method QRgba64 QRgba64::premultiplied()\n", true, &_init_f_premultiplied_c0, &_call_f_premultiplied_c0);
  methods += new qt_gsi::GenericMethod (":red", "@brief Method quint16 QRgba64::red()\n", true, &_init_f_red_c0, &_call_f_red_c0);
  methods += new qt_gsi::GenericMethod ("red8", "@brief Method quint8 QRgba64::red8()\n", true, &_init_f_red8_c0, &_call_f_red8_c0);
  methods += new qt_gsi::GenericMethod ("setAlpha|alpha=", "@brief Method void QRgba64::setAlpha(quint16 _alpha)\n", false, &_init_f_setAlpha_1100, &_call_f_setAlpha_1100);
  methods += new qt_gsi::GenericMethod ("setBlue|blue=", "@brief Method void QRgba64::setBlue(quint16 _blue)\n", false, &_init_f_setBlue_1100, &_call_f_setBlue_1100);
  methods += new qt_gsi::GenericMethod ("setGreen|green=", "@brief Method void QRgba64::setGreen(quint16 _green)\n", false, &_init_f_setGreen_1100, &_call_f_setGreen_1100);
  methods += new qt_gsi::GenericMethod ("setRed|red=", "@brief Method void QRgba64::setRed(quint16 _red)\n", false, &_init_f_setRed_1100, &_call_f_setRed_1100);
  methods += new qt_gsi::GenericMethod ("toArgb32", "@brief Method unsigned int QRgba64::toArgb32()\n", true, &_init_f_toArgb32_c0, &_call_f_toArgb32_c0);
  methods += new qt_gsi::GenericMethod ("toRgb16", "@brief Method unsigned short int QRgba64::toRgb16()\n", true, &_init_f_toRgb16_c0, &_call_f_toRgb16_c0);
  methods += new qt_gsi::GenericMethod ("unpremultiplied", "@brief Method QRgba64 QRgba64::unpremultiplied()\n", true, &_init_f_unpremultiplied_c0, &_call_f_unpremultiplied_c0);
  methods += new qt_gsi::GenericStaticMethod ("fromArgb32", "@brief Static method QRgba64 QRgba64::fromArgb32(unsigned int rgb)\nThis method is static and can be called without an instance.", &_init_f_fromArgb32_1772, &_call_f_fromArgb32_1772);
  methods += new qt_gsi::GenericStaticMethod ("fromRgba", "@brief Static method QRgba64 QRgba64::fromRgba(quint8 red, quint8 green, quint8 blue, quint8 alpha)\nThis method is static and can be called without an instance.", &_init_f_fromRgba_3888, &_call_f_fromRgba_3888);
  methods += new qt_gsi::GenericStaticMethod ("fromRgba64", "@brief Static method QRgba64 QRgba64::fromRgba64(quint64 c)\nThis method is static and can be called without an instance.", &_init_f_fromRgba64_1103, &_call_f_fromRgba64_1103);
  methods += new qt_gsi::GenericStaticMethod ("fromRgba64", "@brief Static method QRgba64 QRgba64::fromRgba64(quint16 red, quint16 green, quint16 blue, quint16 alpha)\nThis method is static and can be called without an instance.", &_init_f_fromRgba64_4076, &_call_f_fromRgba64_4076);
  return methods;
}

gsi::Class<QRgba64> decl_QRgba64 ("QtGui", "QRgba64",
  methods_QRgba64 (),
  "@qt\n@brief Binding of QRgba64");


GSI_QTGUI_PUBLIC gsi::Class<QRgba64> &qtdecl_QRgba64 () { return decl_QRgba64; }

}

